﻿﻿/*************************** Ccay IGrid Header ***********************************/
(function(IGrid) {
	var headerMsg = IGrid.Const.I18n.header = {
		sortType : "ccay.common.igrid.sortType",
		remoteSort : "ccay.common.igrid.remoteSort",
		staticSort : "ccay.common.igrid.staticSort",
		sortAsc : "ccay.common.igrid.sortAsc",
		sortDesc : "ccay.common.igrid.sortDesc"
	};
	
	var GridHeader = IGrid.header = {
		/** @description 设置列的编辑器配置
		 *  @param {Object} grid IGrid对象
		 *  @param {Object} col 列的配置信息
		 *  @param {Object} op IGrid配置信息
		 */
		setCol : function(grid, col, op) {
			if (!col.hidden) {
				// 设置列头模板
				col.headHtml = "<span>" + (col.header || col.customHeader || "") + "</span>";
				if (!col.inner && !col.columnType) {
					// grid允许排序时，进行列的排序设置
					if ((op.allowSort && col.sortable !== false) || (op.allowFilter && col.filter && op.switchMode != "search")) {
						GridHeader.setSort(grid, col);
					}
					// grid允许拖拽时，进行列的拖拽设置
					op.allowResize && col.resizable !== false && GridHeader.setResize(grid, col);
				} else {
					op.allowResize && col.resizable && GridHeader.setResize(grid, col);
				}
			}
		},
		/** @description 列的排序设置
		 *  @param {Object} grid IGrid对象
		 *  @param {Object} col 列的配置信息
		 */
		setSort : function(grid, col) {
			// 设置表头排序样式
			col._headCss += ' sort';
			// 设置排序字段
			col.sortField || (col.sortField = col.field);
			// 设置默认排序参数，并设置排序图标
			var opSort = grid.op.sort, tempSort;
//			// 设置排序图标
			if (opSort || col.sort) {
				if (opSort) {
					tempSort = opSort.split(" ");
					if (tempSort[0] == col.sortField ) {
						col.headHtml = "<div class='g-sort active " + tempSort[1] + "'></div>" + col.headHtml;
					} else {
						col.headHtml = "<div class='g-sort'></div>" + col.headHtml;
					}
				} else {
					grid.op.sort = col.sortField + ' ' + col.sort;
					col.headHtml = "<div class='g-sort active " + col.sort + "'></div>" + col.headHtml;
				}
			} else {
				col.headHtml = "<div class='g-sort'></div>" + col.headHtml;
			}
		},
		/** @description 列的排序事件
		 *  @param {Object} e 事件对象
		 *  @param {Object} cell 单元格对象
		 *  @param {Object} grid IGrid对象
		 */
		sortClick : function(cell, li) {
			var grid = Ccay.UI.IGrid.Helper.getGrid(cell).manager(),
				op = grid.op, target = cell.children().children('.g-sort'), 
				sort = li.hasClass("asc") ? "asc" : "desc", 
				sortField = grid.getColumnOp(cell).sortField, 
				filter = '.active';
			// 更新排序状态
			grid.getHeadTable().find('.active').attr("class", "g-sort")
			target.addClass("active " + sort);
			op.sort = sortField + ' ' + sort;
			// 执行排序事件
			if (!op.fnSort || op.fnSort.call(grid, sortField, sort, cell) !== false) {
				!op._loadType && (op._loadType = "sort");
				// 服务端排序
				if (op.remoteSort)
					grid.reload(true);
				else {
					// 当前静态数据排序
					op._staticSort = true;
					op.Storage.sort(sortField, sort);
					grid.reload();
				}
			}
		},
		/** @description 列的最小宽度设置
		 *  @param {Object} grid IGrid对象
		 */
		autoSize : function(grid) {
			// 当表头不折行时，设置最小宽度
			grid.op.wrapHead || grid.getHeadTable().find("span").each(function() {
						var span = $(this);
						span.parent().attr('minwidth', span.width() + 30);
					});
		},
		/** @description 列的拖动设置列的大小
		 *  @param {Object} grid IGrid对象
		 *  @param {Object} col 列的配置信息
		 */
		setResize : function(grid, col) {
			grid.op._resizeColNum++;
			// 表头模板中添加拖拽样式及事件
			col.headHtml = "<div eno='resize' class='g-resize disabled'></div>" + col.headHtml;
		},
		/** @description 绑定拖动设置大小事件
		 *  @param {Object} grid IGrid对象
		 *  @param {Object} op grid的配置信息
		 */
		bindResize : function(grid, op) {
			// 设置列的最小宽度
			GridHeader.autoSize(grid);
			var maxLeft, minLeft,
			// 创建拖动线
			moveLine = $.create('div', 'ccay-igrid-moveLine').appendTo(grid.getContent());
			// 拖动参数设置
			var dragOp = {
				target : '.g-resize',
				handler : moveLine,
				virtual : false,
				fixed : {
					y : -2
				},
				// 修正拖拽的对象的显示
				fnFiexdPosition : function(trigger, pos, mover) {
					pos.top = 0;
					pos.left += trigger.parent().position().left;
					return pos;
				},
				// 开始拖拽事件
				onDragStart : function(e, pos, mover, trigger) {
					
					var cell = trigger.parent(), cellLeft = cell.position().left, content = grid.getContent(), col, scrollWidth;
					// 拖拽区间，设置最大最小值
					minLeft = cellLeft + (op.wrapHead ? 50 : (cell.attr("minwidth") * 1 + 30));
					maxLeft = content.width() + 200; 
					if(op.beforeColResize){
						 op.beforeColResize.call(grid, col, cell)
					}
					// 若不是百分比设置，则选取最大值及滚动条宽度之间最小值为最大设置
					if (!op.percentWidth) {
						// 若存在竖向滚动条，则横向滚动宽度减去竖向滚动条的宽度
						if (grid.getBodyPanel().height() < grid.getBodyTable().outerHeight()) {
							scrollWidth = cellLeft + grid.getScrollPanelWidth() - 17;
						} else {
							scrollWidth = cellLeft + grid.getScrollPanelWidth() - 1;
						}
						maxLeft = Math.min(maxLeft, scrollWidth - 5);
						// 若存在冻结列，则最大值为单元格的宽度加上非冻结区域的宽度
						col = grid.getColumnOp(cell);
						if (op.allowFreezen && col.freezeable) {
							maxLeft = cell.width() + scrollWidth;
						}
					}
					// 若最大值小于最小值，则将最小值赋给最大值
					(maxLeft < minLeft) && (maxLeft = minLeft);
					// 设置拖拽线的高度
					mover.height(content.height());
				},
				// 拖拽
				onMoving : function(e, pos, mover, trigger) {
					// 判断最大最小值
					if (pos.left > maxLeft)
						pos.left = maxLeft;
					else if (pos.left < minLeft)
						pos.left = minLeft;
					// 设置拖拽线的左边距
					mover.css('left', pos.left);
					return false;
				},
				// 拖拽结束
				onDroped : function(e, pos, mover, trigger) {
					var cell = trigger.parent(), col = grid.getColumnOp(cell), 
					// 需要加上拖拽线与表格右边距的间隙，修正点击拖拽线后无限缩小的问题
					width = pos.left - cell.position().left + (cell.width() - trigger.position().left);
					// 列设置大小改变事件
					if (!op.fnResize || op.fnResize.call(grid, width, col, cell) !== false) {
						col.width = width;
						// 设置列宽度
						grid.setColWidth(cell, width);
						mover.hide();
						minLeft = null;
					}
					
					//防止当前拖拽除非cell的click事件 add by chenzhiwu
					cell.one("click.current",function(){
							return false;
					})
					setTimeout(function(){
						cell.unbind("click.current");
					},10);
				}
			};
			// 设置表头的拖拽
			grid.getHeadTable().drag(dragOp);
		},
		/** @description 自定义表头
		 *  @param {Object} grid IGrid对象
		 *  @param {Object} op grid的配置信息
		 */
		customHead : function(grid, op) {
			var cusHead = $(op.customHead);
			// 存在自定义表头，则设置表头单元格
			cusHead.length && GridHeader.setTd(grid, op, cusHead);
		},
		/** @description 设置定义表头单元格
		 *  @param {Object} grid IGrid对象
		 *  @param {Object} op grid的配置信息
		 *  @param {Object} head 定义表头对象
		 */
		setTd : function(grid, op, head) {
			// 遍历单元格
			grid.getHeadTable().children('.igrid-head').html(head.children().html()).find('td[field]').each(function(i) {
				var td = $(this), field = td.attr('field'), col = Ccay.Format.getArrayItem(field, op.columns, '_ctype');
				// 设置样式和属性
				td.addClass("grid-cell " + col._indexCss + " " + (col._headCss || col.headCss || '')).attr("_col", col._i);
				col.headENo && td.attr("eno", col.headENo);
				// 设置宽度
				var width = Ccay.Format.getPixe(col.width);
				td.width(width);
				var child = td.children();
				if (child.length) {
					// 子元素设置
					child.addClass("igrid-innercell");
					child.append(col.headHtml);
				} else {
					// 非子元素的设置
					var html = ["<div class='igrid-innercell'"];
					html.push(">", col.headHtml, '</div>')
					td.html(html.join(""));
				}
			});
		}
	};
	
	/** 注册表头插件 */
	Ccay.UI.XControl.addPlugin("XGrid", "header", {
				build : function(grid, op) {
					// 列头设置
					op.handler.setColumn.add(GridHeader.setCol);
					// 添加排序事件
					if (op.allowSort) {
						op.headMenus=[
							{text: "ccay.common.igrid.sortAsc", click: GridHeader.sortClick, css: "asc", icon: "sort-asce"}, 
							{text: "ccay.common.igrid.sortDesc", click: GridHeader.sortClick,  css: "desc", icon: "sort-desc"}
						];
						op.handler.click.add("sort", GridHeader.sortClick);
					}
					// 绑定拖拽操作
					if(op.allowResize) {
						//可设置宽度列数量
						op._resizeColNum = 0;
						op.handler.initComplete.add(GridHeader.bindResize);
					}
					// 添加自定义表头
					if (op.customHead) {
						op.allowFilter = false;
						op.handler.initComplete.add(GridHeader.customHead);
					}
				},
				individuation: function (grid, op, gridProps, columnProps, propOp) {
					if (op.allowSort && op.remoteSort) {
						if (!op.lazyLoad) {
							// 服务器端排序设置
							gridProps.remoteSort = {
								type: "bool",
								ePropConf: true,
								ePropName: headerMsg.sortType,
								editor: "enum",
								format: {
									isBool: true,
									data: [
										{value: true, text: $i18n(headerMsg.remoteSort)}, 
										{value: false, text: $i18n(headerMsg.staticSort)}
									]
								}
							};
						}
						// 服务器端排序模式下，设置默认排序列
						columnProps.push({
							field: "sort",
							width: 80,
							header: headerMsg.sortType,
							cssName: "center",
							type: "enum",
							format: {
								data: [
									{value: "asc", text: $i18n(headerMsg.sortAsc)}, 
									{value: "desc", text: $i18n(headerMsg.sortDesc)}
								]
							},
							editorOp : {
								conf : {combo: false}
							},
							fnEndEdit: function (value, rowData, td, col, oldValue) {
								var prevData;
								// 遍历数据集，若该数据是编辑数据，则给sort赋值，否则清除sort值
								this.op.Storage.filter(function(item){
									if (item.sort) {
										// 缓存前一个排序字段
										prevData = item;
									}
					        		item.sort = null;
					        	});
					        	// 将前一个排序字段的单元格清空
					        	if (prevData) {
					        		this.getCellByField(prevData._index, "sort").attr("val", "").html("");
					        	}
							}
						});
						// 设置编辑器改变事件
						propOp.changeHandler.remoteSort = function (name, value, oldValue) {
							// 判断是否存在行渲染设置，存在则根据值进行隐藏或显示
							if (op.rowRender == "group" || op.rowRender == "rowSpan") {
								var rowRenderEditor = this.findByName("rowRenderOp.order"),
									rowRenderRow = rowRenderEditor.parents("tr:first");
								if (value) {
									rowRenderRow.show().prev().show();
								} else {
									// 恢复初始值
									rowRenderEditor.children(":last").manager().setValue(op.rowRenderOp.order || []);
									rowRenderRow.hide().prev().hide();
								}
							}
							var columnsEditor = this.findByName("columns").manager(), hideColIndex;
							// 根据值进行列的排序设置的隐藏或显示
							if (value) {
								columnsEditor.hideColumns();
							} else {
								hideColIndex = columnsEditor.getCellByField(0, "sort").attr('_col') * 1;
								columnsEditor.hideColumns(hideColIndex, hideColIndex + 1);
							}
						}
					}
				}
			});

})(Ccay.UI.IGrid);